Jetpack
Compose

// What you write:
@Composable
fun Greeting(name: String) {
    Text("Hello, $name")
}

// What the compiler generates (simplified):
fun Greeting(
    name: String,
    composer: Composer,   // invisible param added
    changed: Int           // bitmask: which params changed
) {
    // Start a "group" — identifies this call site
    composer.startRestartGroup(key)

    val dirty = changed or /* track if name changed */
    if (dirty != 0) {
        // Only re-execute if something changed
        Text("Hello, $name", composer, ...)
    }

    composer.endRestartGroup()
        ?.updateScope { c, _ -> Greeting(name, c, 1) }
}

// Key rules for composable functions:
// 1. Must be called from another @Composable (or setContent)
// 2. Can NOT be called from regular functions
// 3. Must NOT have side effects — use Effect APIs instead
// 4. Can be called in any order, multiple times (idempotent)

// ✗ UNSTABLE — List is a plain interface, not @Stable
@Composable
fun ItemList(items: List<Item>) { ... }
// Compose can't skip this — always recomposes

// ✓ STABLE — ImmutableList from kotlinx.collections.immutable
@Composable
fun ItemList(items: ImmutableList<Item>) { ... }

// ✓ Or annotate your wrapper class
@Immutable
data class ItemsState(val items: List<Item>)

// ✓ Or use @Stable for classes that notify on change
@Stable
class MyViewModel : ViewModel() { ... }

// ✗ Without key: reorder = all items recompose
LazyColumn {
    items(users) { user ->
        UserRow(user)  // keyed by position — fragile
    }
}

// ✓ With key: reorder = only moved items recompose
LazyColumn {
    items(users, key = { it.id }) { user ->
        UserRow(user)  // keyed by stable ID
    }
}

// ✓ Manual key for conditional composables
key(selectedTab) {
    TabContent(selectedTab)  // discards state on tab change
}

// Local ephemeral state
@Composable
fun ExpandableCard() {
    var expanded by remember { mutableStateOf(false) }

    Card(onClick = { expanded = !expanded }) {
        AnimatedVisibility(visible = expanded) {
            FullContent()
        }
    }
}

// State hoisting — stateless composable
@Composable
fun ExpandableCard(
    expanded: Boolean,        // state in
    onToggle: () -> Unit   // event out
) { ... }

// ViewModel screen state
@Composable
fun HomeScreen(viewModel: HomeViewModel = viewModel()) {
    val uiState by viewModel.uiState
        .collectAsStateWithLifecycle()

    when (val s = uiState) {
        is Loading  -> LoadingSpinner()
        is Success  -> ContentScreen(s.data)
        is Error    -> ErrorScreen(s.message)
    }
}

// rememberSaveable with custom Saver
val color by rememberSaveable(
    stateSaver = ColorSaver
) { mutableStateOf(Color.Red) }

// Compose's snapshot system enables safe multi-threaded reads
// State reads are tracked per-snapshot (like database MVCC)

// Write from background thread safely:
withContext(Dispatchers.Default) {
    // Snapshot.withMutableSnapshot groups writes atomically
    Snapshot.withMutableSnapshot {
        state1.value = newVal1
        state2.value = newVal2
        // observers notified once, not twice
    }
}

// derivedStateOf — computed state, only updates when result changes
val filteredList by remember {
    derivedStateOf { items.filter { it.isActive } }
}
// Recomposes only when the filtered result changes,
// NOT every time items list changes (may be same result)

// Compose INSIDE a View (Fragment/Activity)
val composeView = ComposeView(context).apply {
    setContent {
        MyComposable()  // compose tree starts here
    }
}

// A View INSIDE Compose (for legacy widgets)
@Composable
fun LegacyMapView() {
    AndroidView(
        factory = { ctx -> MapView(ctx).apply { ... } },
        update  = { mapView -> mapView.moveCamera(...) }
    )
}

// Theme bridging — Material3 Compose ↔ AppCompat theme
@Composable
fun App() {
    MdcTheme {          // MaterialThemeAdapter from accompanist
        MyScreens()    // colors/typography from XML theme
    }
}